//
// Description: 棋王鸭鸭
// Created by Loading on 2021/1/30.
//

// 鸭鸭非常喜欢正方形，他会给自己画一个很大的围棋棋盘，每个交叉点的坐标用(x, y)表示，随机摆放四颗棋子，每次可以移动一颗棋子一个单位距离，
// 也就是对点(x,y)的棋子，可以移动到 (x,y+1), (x,y−1), (x+1,y)或者 (x−1,y)这四个位置中的一个。
// 他的目标是让四颗棋子组成一个四条边都和棋盘边缘平行的正方形（边长为0的正方形也可以），同时移动棋子的步数尽可能少。

// Input
// 第一行是整数 t (1≤t≤10^4)，表示测试case的数量
// 每个case包含四行，每行是两个整数x和y(0≤x,y≤10^9)，分别表示四颗棋子的坐标，四个坐标不会有重复
//
// Output
// 对每一个测试case，输出一个整数，表示棋子移动的最小步数

// 示例
//
// 输入
// 3
// 1 6
// 4 1
// 2 5
// 2 2
// 0 2
// 2 4
// 2 0
// 4 2
// 1 0
// 6 0
// 4 0
// 2 0
//
// 输出
// 5
// 8
// 7


#include <bits/stdc++.h>

typedef long long LL;

using namespace std;

int main() {
    int t;
    cin >> t;
    while (t--) {
        vector<int> comb = {0, 1, 2, 3};//排列组合
        LL res = LONG_LONG_MAX;

        vector<pair<int, int>> point(4);
        for (int i = 0; i < 4; ++i) {
            pair<int, int> p;
            cin >> p.first >> p.second;
            point[i] = p;
        }

        do {
            //令point[0]、point[1]、point[2]、point[3]分别位于正方形左上、右上、左下、右下
            //x y坐标分别计算
            //[x1, x2]为左侧两点point[0]和point[2]的移动范围，[x3, x4]为右侧...
            int x1 = min(point[comb[0]].first, point[comb[2]].first);
            int x2 = max(point[comb[0]].first, point[comb[2]].first);
            int x3 = min(point[comb[1]].first, point[comb[3]].first);
            int x4 = max(point[comb[1]].first, point[comb[3]].first);

            //[y1, y2]为上侧两点point[0]和point[1]的移动范围，[y3, y4]为下侧...
            int y1 = min(point[comb[0]].second, point[comb[1]].second);
            int y2 = max(point[comb[0]].second, point[comb[1]].second);
            int y3 = min(point[comb[2]].second, point[comb[3]].second);
            int y4 = max(point[comb[2]].second, point[comb[3]].second);

            //x y坐标的移动次数
            LL cntx = 0, cnty = 0;
            //横纵边长范围
            LL leftx, rightx, lefty, righty;
            if (x4 < x1) {//向四个点的中位数位置移动，边长为0
                leftx = 0;
                rightx = 0;
                cntx = x4 - x3 + abs(x1 - x4) + abs(x2 - x4);
            } else {
                leftx = x3 - x2 > 0 ? x3 - x2 : 0;
                rightx = x4 - x1;
                cntx = x2 - x1 + x4 - x3;
            }

            if (y4 < y1) {//向四个点的中位数位置移动，边长为0
                lefty = 0;
                righty = 0;
                cnty = y4 - y3 + abs(y1 - y4) + abs(y2 - y4);
            } else {
                lefty = y3 - y2 > 0 ? y3 - y2 : 0;
                righty = y4 - y1;
                cnty = y2 - y1 + y4 - y3;
            }

            LL cnt = cntx + cnty;
            //两侧边长范围存在交集时，可以双侧往交集处聚集，不增加额外移动次数
            if ((righty >= leftx && lefty <= rightx) || (rightx >= lefty && leftx <= righty)) {
                //res = res < cnt ? res : cnt;
            } else if (leftx > righty) {//横侧范围大，纵侧两边向横侧对齐
                cnt += (leftx - righty) * 2;
            } else if (lefty > rightx) {//纵侧范围大，横侧两边向横侧对齐
                cnt += (lefty - rightx) * 2;
            }
            res = res < cnt ? res : cnt;

        } while (next_permutation(comb.begin(), comb.end()));//排列组合，暴力枚举4个点的所有情况

        cout << res << endl;
    }
}